<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>绘制环形</title>
    <link rel="stylesheet" href="../css/common.css" />
</head>

<body>
    <canvas id="canvas"></canvas>
    <script type="shader-source" id="vertexShader">
        //浮点数设置为中等精度
        precision mediump float;
        //接收 JavaScript 传递过来的点的坐标（X, Y）
        attribute vec2 a_Position;
        // 接收canvas的尺寸。
        attribute vec2 a_Screen_Size;
        attribute vec4 a_Color;
        varying vec4 v_Color;

        void main(){
            // 将 canvas 的坐标值 转换为 [-1.0, 1.0]的范围。
            vec2 position = (a_Position / a_Screen_Size) * 2.0 - 1.0;
            // canvas的 Y 轴坐标方向和设备坐标系的相反。
            position = position * vec2(1.0, -1.0);
            // 最终的顶点坐标。
            gl_Position = vec4(position, 0.0, 1.0);
            // 将顶点颜色传递给片元着色器
            v_Color = a_Color;

        }
    </script>
    <script type="shader-source" id="fragmentShader">
        //浮点数设置为中等精度
        precision mediump float;
        //全局变量，用来接收 JavaScript传递过来的颜色。
        varying vec4 v_Color;

        void main(){
            // 将颜色处理成 GLSL 允许的范围[0， 1]。
            vec4 color = v_Color / vec4(255, 255, 255, 1);
            // 点的最终颜色。
            gl_FragColor = color;
        }
    </script>
    <script src="../utils/webgl-helper.js"></script>
    <script>
    function createRingVertex(x, y, innerRadius, outerRadius, n) {
        let positions = [];
        let color = randomColor();
        for (let i = 0; i <= n; i++) {
            if (i % (n / 4) == 0) {
                color = randomColor();
            }
            let angle = (i * Math.PI * 2) / n;
            positions.push(
                x + innerRadius * Math.sin(angle),
                y + innerRadius * Math.cos(angle),
                color.r,
                color.g,
                color.b,
                1
            );
            positions.push(
                x + outerRadius * Math.sin(angle),
                y + outerRadius * Math.cos(angle),
                color.r,
                color.g,
                color.b,
                1
            )
        }
        let indices = [];
        for (let i = 0; i < n; i++) {
            let p0 = i * 2;
            let p1 = i * 2 + 1;
            let p2 = (i + 1) * 2 + 1;
            let p3 = (i + 1) * 2;
            if (i == n - 1) {
                p2 = 1;
                p3 = 0;
            }
            indices.push(p0, p1, p2, p2, p3, p0);
        }
        return { positions: positions, indices: indices };
    }
    //获取canvas
    let canvas = getCanvas('#canvas');
    //设置canvas尺寸为满屏
    resizeCanvas(canvas);
    //获取绘图上下文
    let gl = getContext(canvas);
    //创建着色器程序
    let program = createSimpleProgramFromScript(gl, 'vertexShader', 'fragmentShader');

    //使用该着色器程序
    gl.useProgram(program);

    // 随机生成一个颜色。
    let color = randomColor();
    // 找到着色器中的全局变量 u_Color;
    let u_Color = gl.getUniformLocation(program, 'u_Color');
    // 将随机颜色传递给给全局变量
    gl.uniform4f(u_Color, color.r, color.g, color.b, color.a);
    // 获取 canvas 尺寸。
    let a_Screen_Size = gl.getAttribLocation(program, 'a_Screen_Size');
    // 将 canvas 尺寸传递给顶点着色器。
    gl.vertexAttrib2f(a_Screen_Size, canvas.width, canvas.height);

    // 定义组成矩形的两个三角形，共计四个顶点，每个顶点包含2个坐标分量和4个颜色分量，其中 V0,V1,V2代表左下角三角形，V1,V2,V3代表右上角三角形。
    let vertex = createRingVertex(100, 100, 20, 80, 100);
    let positions = vertex.positions;

    let a_Position = gl.getAttribLocation(program, 'a_Position');
    let a_Color = gl.getAttribLocation(program, 'a_Color');

    gl.enableVertexAttribArray(a_Position);
    gl.enableVertexAttribArray(a_Color);
    // 创建缓冲区
    let buffer = gl.createBuffer();
    // 绑定缓冲区为当前缓冲
    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
    // 设置 a_Position 属性从缓冲区读取数据方式
    gl.vertexAttribPointer(a_Position, 2, gl.FLOAT, false, 24, 0);
    // 设置 a_Color 属性从缓冲区读取数据方式
    gl.vertexAttribPointer(a_Color, 4, gl.FLOAT, false, 24, 8);
    // 向缓冲区传递数据
    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(positions), gl.STATIC_DRAW);

    //定义绘制索引数组
    let indices = vertex.indices;
    //创建索引缓冲区
    let indicesBuffer = gl.createBuffer();
    //绑定索引缓冲区
    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indicesBuffer);
    //向索引缓冲区传递索引数据
    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);

    //设置清屏颜色为黑色。
    gl.clearColor(0, 0, 0, 1);


    /*渲染*/
    function render(gl) {
        gl.clear(gl.COLOR_BUFFER_BIT);
        gl.drawElements(gl.TRIANGLES, indices.length, gl.UNSIGNED_SHORT, 0);
    }
    render(gl);
    </script>
</body>

</html>